﻿


using Csla;
using Csla.Data;
using System;
using System.Linq;


namespace Kiosk.Library
{

	#region CellProviderList
	[Serializable()]
	public partial class CellProviderList : BusinessListBase<CellProviderList, CellProvider>
    {
	
    #region  Business Methods

    public CellProvider GetItem(Guid CellProviderId)
    {
      foreach (CellProvider item in this)
        if (item.CellProviderID == CellProviderId)
          return item;
      return null;
    }

    public bool Contains(Guid CellProviderId)
    {
      foreach (CellProvider item in this)
        if (item.CellProviderID == CellProviderId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid CellProviderId)
    {
      foreach (CellProvider item in DeletedList)
        if (item.CellProviderID == CellProviderId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static CellProviderList NewCellProviderList()
    {
      return DataPortal.CreateChild<CellProviderList>();
    }

	/*
    internal static CellProviderList GetCellProviderList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<CellProviderList>(data);
    }*/

    private CellProviderList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(CellProvider.GetCellProvider(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region EmployeeList
	[Serializable()]
	public partial class EmployeeList : BusinessListBase<EmployeeList, Employee>
    {
	
    #region  Business Methods

    public Employee GetItem(Guid EmployeeId)
    {
      foreach (Employee item in this)
        if (item.EmployeeID == EmployeeId)
          return item;
      return null;
    }

    public bool Contains(Guid EmployeeId)
    {
      foreach (Employee item in this)
        if (item.EmployeeID == EmployeeId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid EmployeeId)
    {
      foreach (Employee item in DeletedList)
        if (item.EmployeeID == EmployeeId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static EmployeeList NewEmployeeList()
    {
      return DataPortal.CreateChild<EmployeeList>();
    }

	/*
    internal static EmployeeList GetEmployeeList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<EmployeeList>(data);
    }*/

    private EmployeeList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Employee.GetEmployee(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region IconList
	[Serializable()]
	public partial class IconList : BusinessListBase<IconList, Icon>
    {
	
    #region  Business Methods

    public Icon GetItem(Guid IconId)
    {
      foreach (Icon item in this)
        if (item.IconID == IconId)
          return item;
      return null;
    }

    public bool Contains(Guid IconId)
    {
      foreach (Icon item in this)
        if (item.IconID == IconId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid IconId)
    {
      foreach (Icon item in DeletedList)
        if (item.IconID == IconId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static IconList NewIconList()
    {
      return DataPortal.CreateChild<IconList>();
    }

	/*
    internal static IconList GetIconList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<IconList>(data);
    }*/

    private IconList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Icon.GetIcon(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region LocationList
	[Serializable()]
	public partial class LocationList : BusinessListBase<LocationList, Location>
    {
	
    #region  Business Methods

    public Location GetItem(Guid LocationId)
    {
      foreach (Location item in this)
        if (item.LocationID == LocationId)
          return item;
      return null;
    }

    public bool Contains(Guid LocationId)
    {
      foreach (Location item in this)
        if (item.LocationID == LocationId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid LocationId)
    {
      foreach (Location item in DeletedList)
        if (item.LocationID == LocationId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static LocationList NewLocationList()
    {
      return DataPortal.CreateChild<LocationList>();
    }

	/*
    internal static LocationList GetLocationList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<LocationList>(data);
    }*/

    private LocationList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Location.GetLocation(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region NotificationList
	[Serializable()]
	public partial class NotificationList : BusinessListBase<NotificationList, Notification>
    {
	
    #region  Business Methods

    public Notification GetItem(Guid NotificationId)
    {
      foreach (Notification item in this)
        if (item.NotificationID == NotificationId)
          return item;
      return null;
    }

    public bool Contains(Guid NotificationId)
    {
      foreach (Notification item in this)
        if (item.NotificationID == NotificationId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid NotificationId)
    {
      foreach (Notification item in DeletedList)
        if (item.NotificationID == NotificationId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static NotificationList NewNotificationList()
    {
      return DataPortal.CreateChild<NotificationList>();
    }

	/*
    internal static NotificationList GetNotificationList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<NotificationList>(data);
    }*/

    private NotificationList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Notification.GetNotification(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region NotificationTypeList
	[Serializable()]
	public partial class NotificationTypeList : BusinessListBase<NotificationTypeList, NotificationType>
    {
	
    #region  Business Methods

    public NotificationType GetItem(Guid NotificationTypeId)
    {
      foreach (NotificationType item in this)
        if (item.NotificationTypeID == NotificationTypeId)
          return item;
      return null;
    }

    public bool Contains(Guid NotificationTypeId)
    {
      foreach (NotificationType item in this)
        if (item.NotificationTypeID == NotificationTypeId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid NotificationTypeId)
    {
      foreach (NotificationType item in DeletedList)
        if (item.NotificationTypeID == NotificationTypeId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static NotificationTypeList NewNotificationTypeList()
    {
      return DataPortal.CreateChild<NotificationTypeList>();
    }

	/*
    internal static NotificationTypeList GetNotificationTypeList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<NotificationTypeList>(data);
    }*/

    private NotificationTypeList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(NotificationType.GetNotificationType(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region PresentationList
	[Serializable()]
	public partial class PresentationList : BusinessListBase<PresentationList, Presentation>
    {
	
    #region  Business Methods

    public Presentation GetItem(Guid PresentationId)
    {
      foreach (Presentation item in this)
        if (item.PresentationID == PresentationId)
          return item;
      return null;
    }

    public bool Contains(Guid PresentationId)
    {
      foreach (Presentation item in this)
        if (item.PresentationID == PresentationId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid PresentationId)
    {
      foreach (Presentation item in DeletedList)
        if (item.PresentationID == PresentationId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static PresentationList NewPresentationList()
    {
      return DataPortal.CreateChild<PresentationList>();
    }

	/*
    internal static PresentationList GetPresentationList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<PresentationList>(data);
    }*/

    private PresentationList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Presentation.GetPresentation(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region PresentationStatusList
	[Serializable()]
	public partial class PresentationStatusList : BusinessListBase<PresentationStatusList, PresentationStatus>
    {
	
    #region  Business Methods

    public PresentationStatus GetItem(Guid PresentationStatusId)
    {
      foreach (PresentationStatus item in this)
        if (item.PresentationStatusID == PresentationStatusId)
          return item;
      return null;
    }

    public bool Contains(Guid PresentationStatusId)
    {
      foreach (PresentationStatus item in this)
        if (item.PresentationStatusID == PresentationStatusId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid PresentationStatusId)
    {
      foreach (PresentationStatus item in DeletedList)
        if (item.PresentationStatusID == PresentationStatusId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static PresentationStatusList NewPresentationStatusList()
    {
      return DataPortal.CreateChild<PresentationStatusList>();
    }

	/*
    internal static PresentationStatusList GetPresentationStatusList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<PresentationStatusList>(data);
    }*/

    private PresentationStatusList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(PresentationStatus.GetPresentationStatus(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region PresentationTypeList
	[Serializable()]
	public partial class PresentationTypeList : BusinessListBase<PresentationTypeList, PresentationType>
    {
	
    #region  Business Methods

    public PresentationType GetItem(Guid PresentationTypeId)
    {
      foreach (PresentationType item in this)
        if (item.PresentationTypeID == PresentationTypeId)
          return item;
      return null;
    }

    public bool Contains(Guid PresentationTypeId)
    {
      foreach (PresentationType item in this)
        if (item.PresentationTypeID == PresentationTypeId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid PresentationTypeId)
    {
      foreach (PresentationType item in DeletedList)
        if (item.PresentationTypeID == PresentationTypeId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static PresentationTypeList NewPresentationTypeList()
    {
      return DataPortal.CreateChild<PresentationTypeList>();
    }

	/*
    internal static PresentationTypeList GetPresentationTypeList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<PresentationTypeList>(data);
    }*/

    private PresentationTypeList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(PresentationType.GetPresentationType(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
	#region SlideList
	[Serializable()]
	public partial class SlideList : BusinessListBase<SlideList, Slide>
    {
	
    #region  Business Methods

    public Slide GetItem(Guid SlideId)
    {
      foreach (Slide item in this)
        if (item.SlideID == SlideId)
          return item;
      return null;
    }

    public bool Contains(Guid SlideId)
    {
      foreach (Slide item in this)
        if (item.SlideID == SlideId)
          return true;
      return false;
    }

    public bool ContainsDeleted(Guid SlideId)
    {
      foreach (Slide item in DeletedList)
        if (item.SlideID == SlideId)
          return true;
      return false;
    }

    #endregion

    #region  Factory Methods

    internal static SlideList NewSlideList()
    {
      return DataPortal.CreateChild<SlideList>();
    }

	/*
    internal static SlideList GetSlideList(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      return DataPortal.FetchChild<SlideList>(data);
    }*/

    private SlideList()
    { // require use of factory methods 
     }

    #endregion

    #region  Data Access
	/*
    private void Child_Fetch(Kiosk.Data.KioskDataContext.Assignment[] data)
    {
      this.RaiseListChangedEvents = false;
      foreach (var value in data)
        this.Add(Slide.GetSlide(value));
      this.RaiseListChangedEvents = true;
    }
    */

    #endregion

  }
  #endregion
  
  

}